/* eslint-disable */
// 格式化时间 type =3 时间戳转时间 yyyy-mm-dd hh:mm:ss
export const formatDate = (strTime, type = 0) => {
  if (!strTime) {
    return '无'
  }
  if (type === 0) {
    let date = new Date(strTime)
    let year = date.getFullYear()
    let month = date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1
    let day = date.getDate() < 10 ? '0' + date.getDate() : date.getDate()
    let hours = date.getHours() < 10 ? '0' + date.getHours() : date.getHours()
    let minute = date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes()
    let sec = date.getSeconds() < 10 ? '0' + date.getSeconds() : date.getSeconds()
    return year + '-' + month + '-' + day + ' ' + hours + ':' + minute + ':' + sec
  } else if (type === 1) {
    let date = new Date(strTime)
    let year = date.getFullYear()
    let month = date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1
    let day = date.getDate() < 10 ? '0' + date.getDate() : date.getDate()
    return year + '-' + month + '-' + day
  } else if (type === 2) {
    let date = new Date(strTime)
    let hours = date.getHours() < 10 ? '0' + date.getHours() : date.getHours()
    let minute = date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes()
    return hours + ':' + minute
  } else if (type === 3) {
    let date = new Date()
    let year = date.getFullYear()
    var month = date.getMonth() + 1 < 10 ? ('0' + date.getMonth() + 1) : date.getMonth() + 1
    let day = date.getDate() < 10 ? ('0' + date.getDate()) : date.getDate()
    let hours = date.getHours() < 10 ? ('0' + date.getHours()) : date.getHours()
    let minute = date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes()
    let second = date.getSeconds() < 10 ? '0' + date.getSeconds() : date.getSeconds()
    return year + '-' + month + '-' + day + ' ' + hours + ':' + minute + ':' + second
  }
}

// 计算天数差
export const DateDiff = (sDate1,  sDate2) => {    //sDate1和sDate2是2002-12-18格式 
    let  aDate,  oDate1,  oDate2,  iDays 
    aDate  =  sDate1.split("-") 
    oDate1  =  new  Date(aDate[1]  +  '-'  +  aDate[2]  +  '-'  +  aDate[0])    //转换为12-18-2002格式 
    aDate  =  sDate2.split("-") 
    oDate2  =  new  Date(aDate[1]  +  '-'  +  aDate[2]  +  '-'  +  aDate[0]) 
    iDays  =  parseInt(Math.abs(oDate1  -  oDate2)  /  1000  /  60  /  60  /24)    //把相差的毫秒数转换为天数 
    return  iDays 
 }

// 强制保留两位小数
export const toDecimal2 = function (x) {
  var f = parseFloat(x);
  if (isNaN(f)) {
    return x
  }
  var f = Math.round(x*100)/100;
  var s = f.toString();
  var rs = s.indexOf('.')
  if (rs < 0) {
    rs = s.length
    s += '.'
  }
  while (s.length <= rs + 2) {
    s += '0'
  }
  return s
}

// 浮点计算方法
export const FloatFun = {
  /**
  * 加法运算，避免数据相加小数点后产生多位数和计算精度损失。
  *
  * @param num1加数1 | num2加数2
  */
  'add': function(num1, num2) {
      var baseNum, baseNum1, baseNum2;
      try {
          baseNum1 = num1.toString().split(".")[1].length;
      } catch (e) {
          baseNum1 = 0;
      }
       try {
          baseNum2 = num2.toString().split(".")[1].length;
      } catch (e) {
          baseNum2 = 0;
      }
      baseNum = Math.pow(10, Math.max(baseNum1, baseNum2));
      return parseInt((num1 * baseNum + num2 * baseNum) / baseNum * 10000) / 10000;
  },
  /**
  * 减法运算，避免数据相减小数点后产生多位数和计算精度损失。
  *
  * @param num1被减数  |  num2减数
  */
  'sub': function(num1, num2) {
      var baseNum, baseNum1, baseNum2;
      var precision;// 精度
      try {
          baseNum1 = num1.toString().split(".")[1].length;
      } catch (e) {
           baseNum1 = 0;
      }
      try {
          baseNum2 = num2.toString().split(".")[1].length;
      } catch (e) {
          baseNum2 = 0;
      }
      baseNum = Math.pow(10, Math.max(baseNum1, baseNum2));
      precision = (baseNum1 >= baseNum2) ? baseNum1 : baseNum2;
      return parseInt(((num1 * baseNum - num2 * baseNum) / baseNum).toFixed(precision) * 10000) / 10000;
  },
  /**
  * 乘法运算，避免数据相乘小数点后产生多位数和计算精度损失。
  *
  * @param num1被乘数 | num2乘数
  */
  'multi': function(num1, num2) {
      var baseNum = 0;
      try {
          baseNum += num1.toString().split(".")[1].length;
      } catch (e) {
      }
      try {
          baseNum += num2.toString().split(".")[1].length;
      } catch (e) {
      }
      return parseInt(Number(num1.toString().replace(".", "")) * Number(num2.toString().replace(".", "")) / Math.pow(10, baseNum) * 10000) / 10000;
  },
  /**
  * 除法运算，避免数据相除小数点后产生多位数和计算精度损失。
  *
  * @param num1被除数 | num2除数
  */
//			'div': function(num1, num2) {
//		    	var baseNum1 = 0, baseNum2 = 0;
//		    	var baseNum3, baseNum4;
//		    	try {
//		        	baseNum1 = num1.toString().split(".")[1].length;
//		    	} catch (e) {
//		        	baseNum1 = 0;
//		    	}
//		    	try {
//		        	baseNum2 = num2.toString().split(".")[1].length;
//		    	} catch (e) {
//		        	baseNum2 = 0;
//		    	}
//		    	with (Math) {
//		        	baseNum3 = Number(num1.toString().replace(".", ""));
//		        	baseNum4 = Number(num2.toString().replace(".", ""));
//		        	return parseInt((baseNum3 / baseNum4) * pow(10, baseNum2 - baseNum1) * 10000) / 10000;
//		    	}
//			}
}

/**
 * 缓存图片方法
 * @param {String} imgSrc // 图片地址
 * @param {Number} outTime // 超时时间,单位:秒,默认5
 * @param {Boolean} reload // 是否放弃原有缓存，重新载入，默认false(使用缓存)
 */
const loadImgsArr = {} // 缓存数据池，防止多次请求导致失败

export const imgLoad = function(imgUrl, outTime, reload) {
    return new Promise((resolve, reject) => {
        // 查询缓存
        if (!reload && loadImgsArr.hasOwnProperty(imgUrl)) {
            resolve(loadImgsArr[imgUrl])
            return
        }
        window.URL = window.URL || window.webkitURL;
        var xhr = new XMLHttpRequest();
        xhr.open("get", imgUrl + (reload ? ('?v=' + Math.random()) : ''), true);
        // 至关重要
        xhr.responseType = "blob";
        xhr.onload = function () {
            if (this.status == 200) {
                //得到一个blob对象
                var blob = this.response;
                // 至关重要
                let oFileReader = new FileReader();
                oFileReader.onloadend = function (e) {
                    // 此处拿到的已经是 base64的图片了
                    let base64 = e.target.result;
                    resolve(base64)
                };
                oFileReader.readAsDataURL(blob);
            } else {
                resolve('error')
            }
        }
        // 异常处理
        xhr.onerror = function () {
            resolve('error')
        }
        xhr.send();
        // 超时处理
        let overTime = (outTime || 5)
		setTimeout(() => {
			resolve('error')
        }, overTime * 1000)
    })
    
}

/**
 * 防抖函数(可用于防止重复提交)
 * 当持续触发事件时，一定时间段内没有再触发事件，事件处理函数才会执行一次，
 * 如果设定时间到来之前，又触发了事件，就重新开始延时。也就是说当一个用户一直触发这个函数，
 * 且每次触发函数的间隔小于既定时间，那么防抖的情况下只会执行一次。
 *
 * 2020-4-29改写：立即触发一次，如果下次触发小于设置时间，那么不再触发
 * 
 * @param func 执行函数
 * @param wait 间隔时间 默认300毫秒
 * @param immediate 立即执行
 */
export function debounce(fn, wait = 300, immediate) {
    let timer;
    return function() {
        if (timer) return;
        if (immediate) {
            // 如果已经执行过，不再执行
            var callNow = !timer;
            timer = setTimeout(() => {
                timer = null;
            }, wait)
            if (callNow) {
                fn.apply(this, arguments)
            }
        } else {
            fn.apply(this, arguments)
            timer = setTimeout(() => {
                clearTimeout(timer)
                timer = null
            }, wait);
        }
    }
}

/**
 * 节流函数
 * 当持续触发事件时，保证在一定时间内只调用一次事件处理函数，意思就是说，假设一个用户一直触发这个函数，且每次触发
 * 小于既定值，函数节流会每隔这个时间调用一次
 * 用一句话总结防抖和节流的区别：防抖是将多次执行变为最后一次执行，节流是将多次执行变为每隔一段时间执行
 * 实现函数节流我们主要有两种方法：时间戳和定时器
 *
 * @param func 执行函数
 * @param wait 间隔时间
 * @param options 立即执行
 * options中  leading：false 表示禁用第一次执行 trailing: false 表示禁用停止触发的回调
 */
export function throttle(fn, wait, options = {}) {
    let timer;
    let previous = 0;
    let throttled = function() {
        let now = +new Date();
        // remaining 不触发下一次函数的剩余时间
        if (!previous && options.leading === false) previous = now;
        let remaining = wait - (now - previous);
        if (remaining < 0) {
            if (timer) {
                clearTimeout(timer);
                timer = null;
            }
            previous = now;
            fn.apply(this, arguments)
        } else if (!timer && options.trailing !== false) {
            timer = setTimeout(() => {
                previous = options.leading === false ? 0 : new Date().getTime();
                timer = null;
                fn.apply(this, arguments);
            }, remaining);
        }
    }
    return throttled;
}